home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / lynx-2.4 / WWW / Library / Implementation / HTFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-06-28  |  36.7 KB  |  1,426 lines
  1. /*            File Access                HTFile.c
  2. **            ===========
  3. **
  4. **    This is unix-specific code in general, with some VMS bits.
  5. **    These are routines for file access used by browsers.
  6. **
  7. ** History:
  8. **       Feb 91    Written Tim Berners-Lee CERN/CN
  9. **       Apr 91    vms-vms access included using DECnet syntax
  10. **    26 Jun 92 (JFG) When running over DECnet, suppressed FTP.
  11. **            Fixed access bug for relative names on VMS.
  12. **       Sep 93 (MD)  Access to VMS files allows sharing.
  13. **    15 Nov 93 (MD)    Moved HTVMSname to HTVMSUTILS.C
  14. **      27 Dec 93 (FM)  FTP now works with VMS hosts.
  15. **            FTP path must be Unix-style and cannot include
  16. **             the device or top directory.
  17. */
  18.  
  19. #ifndef VMS
  20. /* #define LONG_LIST  /* Define this for long style unix listings (ls -l) */
  21. /* #define NO_PARENT_DIR_REFERENCE  /* Define this for no parent links */
  22. #endif /* !VMS */
  23.  
  24. #include "HTUtils.h"
  25. #include "HTFile.h"        /* Implemented here */
  26. #ifdef VMS
  27. #include <stat.h>
  28. #endif /* VMS */
  29.  
  30. #ifndef VMS
  31. #ifdef LONG_LIST
  32. #include <pwd.h>
  33. #include <grp.h>
  34. #endif /* LONG_LIST */
  35. #endif /* !VMS */
  36.   
  37. #define INFINITY 512        /* file name length @@ FIXME */
  38. #define MULTI_SUFFIX ".multi"   /* Extension for scanning formats */
  39.  
  40. #define HT_EM_SPACE ((char)2)
  41.  
  42. #define FREE(x) if (x) {free(x); x = NULL;}
  43.  
  44. #ifdef VMS
  45. #include "HTVMSUtils.h"
  46. #endif /* VMS */
  47.  
  48. #include "HTParse.h"
  49. #include "tcp.h"
  50. #include "HTTCP.h"
  51. #ifndef DECNET
  52. #include "HTFTP.h"
  53. #endif /* !DECNET */
  54. #include "HTAnchor.h"
  55. #include "HTAtom.h"
  56. #include "HTWriter.h"
  57. #include "HTFWriter.h"
  58. #include "HTInit.h"
  59. #include "HTBTree.h"
  60.  
  61. #include "LYexit.h"
  62. #include "LYLeaks.h"
  63.  
  64. typedef struct _HTSuffix {
  65.     char *        suffix;
  66.     HTAtom *    rep;
  67.     HTAtom *    encoding;
  68.     float        quality;
  69. } HTSuffix;
  70.  
  71. #ifndef NGROUPS
  72. #ifdef NGROUPS_MAX
  73. #define NGROUPS NGROUPS_MAX
  74. #else
  75. #define NGROUPS 32
  76. #endif /* NGROUPS_MAX */
  77. #endif /* NGROUPS */
  78.  
  79.  
  80. #ifdef USE_DIRENT        /* Set this for Sys V systems */
  81. #define STRUCT_DIRENT struct dirent
  82. #else
  83. #define STRUCT_DIRENT struct direct
  84. #endif /* USE_DIRENT */
  85.  
  86. #include "HTML.h"        /* For directory object building */
  87.  
  88. #define PUTC(c) (*target->isa->put_character)(target, c)
  89. #define PUTS(s) (*target->isa->put_string)(target, s)
  90. #define START(e) (*target->isa->start_element)(target, e, 0, 0)
  91. #define END(e) (*target->isa->end_element)(target, e)
  92. #define FREE_TARGET (*target->isa->_free)(target)
  93. struct _HTStructured {
  94.     CONST HTStructuredClass *    isa;
  95.     /* ... */
  96. };
  97.  
  98.  
  99. /*                   Controlling globals
  100. **
  101. */
  102.  
  103. PUBLIC int HTDirAccess = HT_DIR_OK;
  104.  
  105. #ifdef DIRED_SUPPORT
  106. PUBLIC int HTDirReadme = HT_DIR_README_NONE;
  107. #define FILES_FIRST 1
  108. #define MIXED_STYLE 2
  109. extern BOOLEAN lynx_edit_mode;
  110. extern BOOLEAN dir_list_style;
  111. #else
  112. PUBLIC int HTDirReadme = HT_DIR_README_TOP;
  113. #endif /* DIRED_SUPPORT */
  114.  
  115. PRIVATE char *HTMountRoot = "/Net/";        /* Where to find mounts */
  116. #ifdef VMS
  117. PRIVATE char *HTCacheRoot = "/WWW$SCRATCH";   /* Where to cache things */
  118. #else
  119. PRIVATE char *HTCacheRoot = "/tmp/W3_Cache_";   /* Where to cache things */
  120. #endif /* VMS */
  121.  
  122. /* PRIVATE char *HTSaveRoot  = "$(HOME)/WWW/";*/    /* Where to save things */
  123.  
  124.  
  125. /*    Suffix registration
  126. */
  127.  
  128. PRIVATE HTList * HTSuffixes = 0;
  129. PRIVATE HTSuffix no_suffix = { "*", NULL, NULL, 1.0 };
  130. PRIVATE HTSuffix unknown_suffix = { "*.*", NULL, NULL, 1.0};
  131.  
  132. /*
  133.  *    To free up the suffixes at program exit.
  134.  */
  135. static void free_suffixes NOPARAMS;
  136.  
  137. /*    Define the representation associated with a file suffix
  138. **    -------------------------------------------------------
  139. **
  140. **    Calling this with suffix set to "*" will set the default
  141. **    representation.
  142. **    Calling this with suffix set to "*.*" will set the default
  143. **    representation for unknown suffix files which contain a ".".
  144. **
  145. **    If filename suffix is already defined its previous
  146. **    definition is overridden.
  147. */
  148. PUBLIC void HTSetSuffix ARGS4(
  149.     CONST char *,    suffix,
  150.     CONST char *,    representation,
  151.     CONST char *,    encoding,
  152.     float,        value)
  153. {
  154.     
  155.     HTSuffix * suff;
  156.  
  157.     if (strcmp(suffix, "*")==0) suff = &no_suffix;
  158.     else if (strcmp(suffix, "*.*")==0) suff = &unknown_suffix;
  159.     else {
  160.     HTList *cur = HTSuffixes;
  161.  
  162.     while (NULL != (suff = (HTSuffix*)HTList_nextObject(cur))) {
  163.         if (suff->suffix && 0==strcmp(suff->suffix, suffix))
  164.         break;
  165.     }
  166.     if (!suff) { /* Not found -- create a new node */
  167.         suff = (HTSuffix*) calloc(1, sizeof(HTSuffix));
  168.         if (suff == NULL) outofmem(__FILE__, "HTSetSuffix");
  169.  
  170.         /*
  171.              *    Memory leak fixed.
  172.          *    05-28-94 Lynx 2-3-1 Garrett Arch Blythe
  173.          */    
  174.         if (!HTSuffixes)    {
  175.         HTSuffixes = HTList_new();
  176.         atexit(free_suffixes);
  177.         }
  178.  
  179.         HTList_addObject(HTSuffixes, suff);
  180.     
  181.         StrAllocCopy(suff->suffix, suffix);
  182.     }
  183.     }
  184.  
  185.     suff->rep = HTAtom_for(representation);
  186.    
  187.     /*
  188.      *    Memory leak fixed.
  189.      *    05-28-94 Lynx 2-3-1 Garrett Arch Blythe
  190.      *    Invariant code removed.
  191.      */
  192.     suff->encoding = HTAtom_for(encoding);
  193.     
  194.     suff->quality = value;
  195. }
  196.  
  197. static void free_suffixes NOARGS    {
  198. /*
  199.  *    Purpose:    Free all added suffixes.
  200.  *    Arguments:    void
  201.  *    Return Value:    void
  202.  *    Remarks/Portability/Dependencies/Restrictions:
  203.  *        To be used at program exit.
  204.  *    Revision History:
  205.  *        05-28-94    created Lynx 2-3-1 Garrett Arch Blythe
  206.  */
  207.  
  208.     /*
  209.      *    Loop through all suffixes.
  210.      */
  211.     while(!HTList_isEmpty(HTSuffixes))    {
  212.         /*
  213.          *    Free off each item and its members if need be.
  214.          */
  215.         free(HTList_removeLastObject(HTSuffixes));
  216.     }
  217.     /*
  218.      *    Free off the list itself.
  219.       */
  220.     HTList_delete(HTSuffixes);
  221. }
  222.  
  223.  
  224.  
  225.  
  226.  
  227. /*    Send README file
  228. **
  229. **  If a README file exists, then it is inserted into the document here.
  230. */
  231.  
  232. #ifdef GOT_READ_DIR
  233. PRIVATE void do_readme ARGS2(HTStructured *, target, CONST char *, localname)
  234. { 
  235.     FILE * fp;
  236.     char * readme_file_name = 
  237.     malloc(strlen(localname)+ 1 + strlen(HT_DIR_README_FILE) + 1);
  238.     strcpy(readme_file_name, localname);
  239.     strcat(readme_file_name, "/");
  240.     strcat(readme_file_name, HT_DIR_README_FILE);
  241.     
  242.     fp = fopen(readme_file_name,  "r");
  243.     
  244.     if (fp) {
  245.     HTStructuredClass targetClass;
  246.     
  247.     targetClass =  *target->isa;    /* (Can't init agregate in K&R) */
  248.     START(HTML_PRE);
  249.     for(;;){
  250.         char c = fgetc(fp);
  251.         if (c == (char)EOF) break;
  252.         switch (c) {
  253.             case '&':
  254.         case '<':
  255.         case '>':
  256.             PUTC('&');
  257.             PUTC('#');
  258.             PUTC((char)(c / 10));
  259.             PUTC((char) (c % 10));
  260.             PUTC(';');
  261.             break;
  262. /*            case '\n':
  263.             PUTC('\r');    
  264. Bug removed thanks to joe@athena.mit.edu */            
  265.         default:
  266.             PUTC(c);
  267.         }
  268.     }
  269.     END(HTML_PRE);
  270.     fclose(fp);
  271.     } 
  272. }
  273. #endif /* GOT_READ_DIR */
  274.  
  275.  
  276. /*    Make the cache file name for a W3 document
  277. **    ------------------------------------------
  278. **    Make up a suitable name for saving the node in
  279. **
  280. **    E.g.    /tmp/WWW_Cache_news/1234@cernvax.cern.ch
  281. **        /tmp/WWW_Cache_http/crnvmc/FIND/xx.xxx.xx
  282. **
  283. ** On exit,
  284. **    returns    a malloc'ed string which must be freed by the caller.
  285. */
  286. PUBLIC char * HTCacheFileName ARGS1(CONST char *,name)
  287. {
  288.     char * access = HTParse(name, "", PARSE_ACCESS);
  289.     char * host = HTParse(name, "", PARSE_HOST);
  290.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  291.     
  292.     char * result;
  293.     result = (char *)malloc(
  294.         strlen(HTCacheRoot)+strlen(access)
  295.         +strlen(host)+strlen(path)+6+1);
  296.     if (result == NULL) outofmem(__FILE__, "HTCacheFileName");
  297.     sprintf(result, "%s/WWW/%s/%s%s", HTCacheRoot, access, host, path);
  298.     FREE(path);
  299.     FREE(access);
  300.     FREE(host);
  301.     return result;
  302. }
  303.  
  304.  
  305. /*    Open a file for write, creating the path
  306. **    ----------------------------------------
  307. */
  308. #ifdef NOT_IMPLEMENTED
  309. PRIVATE int HTCreatePath ARGS1(CONST char *,path)
  310. {
  311.     return -1;
  312. }
  313. #endif /* NOT_IMPLEMENTED */
  314.  
  315. /*    Convert filenames between local and WWW formats
  316. **    -----------------------------------------------
  317. **    Make up a suitable name for saving the node in
  318. **
  319. **    E.g.    $(HOME)/WWW/news/1234@cernvax.cern.ch
  320. **        $(HOME)/WWW/http/crnvmc/FIND/xx.xxx.xx
  321. **
  322. ** On exit,
  323. **    returns    a malloc'ed string which must be freed by the caller.
  324. */
  325. PUBLIC char * HTLocalName ARGS1(CONST char *,name)
  326. {
  327.     char * access = HTParse(name, "", PARSE_ACCESS);
  328.     char * host = HTParse(name, "", PARSE_HOST);
  329.     char * path = HTParse(name, "", PARSE_PATH+PARSE_PUNCTUATION);
  330.     
  331.     HTUnEscape(path);    /* Interpret % signs */
  332.     
  333.     if (0==strcmp(access, "file")) { /* local file */
  334.         FREE(access);    
  335.     if ((0==strcasecomp(host, HTHostName())) ||
  336.         (0==strcasecomp(host, "localhost")) || !*host) {
  337.         FREE(host);
  338.         if (TRACE) fprintf(stderr, "Node `%s' means path `%s'\n", name, path);
  339.         return(path);
  340.     } else {
  341.         char * result = (char *)malloc(
  342.                     strlen("/Net/")+strlen(host)+strlen(path)+1);
  343.               if (result == NULL) outofmem(__FILE__, "HTLocalName");
  344.         sprintf(result, "%s%s%s", "/Net/", host, path);
  345.         FREE(host);
  346.         FREE(path);
  347.         if (TRACE) fprintf(stderr, "Node `%s' means file `%s'\n", name, result);
  348.         return result;
  349.     }
  350.     } else {  /* other access */
  351.     char * result;
  352. #ifdef VMS
  353.         char * home =  getenv("HOME");
  354.     if (!home) 
  355.         home = HTCacheRoot; 
  356.     else
  357.            home = HTVMS_wwwName(home);
  358. #else
  359.         CONST char * home =  (CONST char*)getenv("HOME");
  360.     if (!home) home = "/tmp"; 
  361. #endif /* VMS */
  362.     result = (char *)malloc(
  363.         strlen(home)+strlen(access)+strlen(host)+strlen(path)+6+1);
  364.       if (result == NULL) outofmem(__FILE__, "HTLocalName");
  365.     sprintf(result, "%s/WWW/%s/%s%s", home, access, host, path);
  366.     FREE(path);
  367.     FREE(access);
  368.     FREE(host);
  369.     return result;
  370.     }
  371. }
  372.  
  373.  
  374. /*    Make a WWW name from a full local path name
  375. **
  376. ** Bugs:
  377. **    At present, only the names of two network root nodes are hand-coded
  378. **    in and valid for the NeXT only. This should be configurable in
  379. **    the general case.
  380. */
  381.  
  382. PUBLIC char * WWW_nameOfFile ARGS1 (CONST char *,name)
  383. {
  384.     char * result;
  385. #ifdef NeXT
  386.     if (0==strncmp("/private/Net/", name, 13)) {
  387.     result = (char *)malloc(7+strlen(name+13)+1);
  388.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  389.     sprintf(result, "file://%s", name+13);
  390.     } else
  391. #endif /* NeXT */
  392.     if (0==strncmp(HTMountRoot, name, 5)) {
  393.     result = (char *)malloc(7+strlen(name+5)+1);
  394.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  395.     sprintf(result, "file://%s", name+5);
  396.     } else {
  397.         result = (char *)malloc(7+strlen(HTHostName())+strlen(name)+1);
  398.     if (result == NULL) outofmem(__FILE__, "WWW_nameOfFile");
  399.     sprintf(result, "file://%s%s", HTHostName(), name);
  400.     }
  401.     if (TRACE) fprintf(stderr, "File `%s'\n\tmeans node `%s'\n", name, result);
  402.     return result;
  403. }
  404.  
  405.  
  406. /*    Determine a suitable suffix, given the representation
  407. **    -----------------------------------------------------
  408. **
  409. ** On entry,
  410. **    rep    is the atomized MIME style representation
  411. **
  412. ** On exit,
  413. **    returns    a pointer to a suitable suffix string if one has been
  414. **        found, else "".
  415. */
  416. PUBLIC CONST char * HTFileSuffix ARGS1(HTAtom*, rep)
  417. {
  418.     HTSuffix * suff;
  419.     int n;
  420.     int i;
  421.  
  422. #define NO_INIT  /* dont init anymore since I do it in Lynx at startup */
  423. #ifndef NO_INIT    
  424.     if (!HTSuffixes) HTFileInit();
  425. #endif /* !NO_INIT */
  426.     n = HTList_count(HTSuffixes);
  427.     for(i=0; i<n; i++) {
  428.     suff = HTList_objectAt(HTSuffixes, i);
  429.     if (suff->rep == rep) {
  430.         return suff->suffix;        /* OK -- found */
  431.     }
  432.     }
  433.     return "";        /* Dunno */
  434. }
  435.  
  436.  
  437. /*    Determine file format from file name
  438. **    ------------------------------------
  439. **
  440. **    This version will return the representation and also set
  441. **    a variable for the encoding.
  442. **
  443. **    It will handle for example  x.txt, x.txt,Z, x.Z
  444. */
  445.  
  446. PUBLIC HTFormat HTFileFormat ARGS2 (
  447.             CONST char *,    filename,
  448.             HTAtom **,    pencoding)
  449.  
  450. {
  451.     HTSuffix * suff;
  452.     int n;
  453.     int i;
  454.     int lf;
  455. #ifdef VMS
  456.     char *semicolon;
  457. #endif /* VMS */
  458.     extern char LYforce_HTML_mode;
  459.  
  460.     if(LYforce_HTML_mode) {
  461.         LYforce_HTML_mode = FALSE;
  462.         return WWW_HTML;
  463.     }
  464.  
  465. #ifdef VMS
  466.     /*
  467.      * Trim at semicolon if a version number was
  468.      * included, so it doesn't interfere with the
  469.      * code for getting the MIME type. - FM
  470.      */
  471.     if ((semicolon=strchr(filename, ';')) != NULL)
  472.         *semicolon = '\0';
  473. #endif /* VMS */
  474.  
  475. #ifndef NO_INIT    
  476.     if (!HTSuffixes) HTFileInit();
  477. #endif /* !NO_INIT */
  478.     *pencoding = NULL;
  479.     lf  = strlen(filename);
  480.     n = HTList_count(HTSuffixes);
  481.     for(i=0; i<n; i++) {
  482.         int ls;
  483.     suff = HTList_objectAt(HTSuffixes, i);
  484.     ls = strlen(suff->suffix);
  485.     if ((ls <= lf) && 0==strcasecomp(suff->suffix, filename + lf - ls)) {
  486.         int j;
  487.         *pencoding = suff->encoding;
  488.         if (suff->rep) {
  489. #ifdef VMS
  490.         if (semicolon != NULL)
  491.             *semicolon = ';';
  492. #endif /* VMS */
  493.             return suff->rep;        /* OK -- found */
  494.         }
  495.         for(j=0; j<n; j++) {  /* Got encoding, need representation */
  496.         int ls2;
  497.         suff = HTList_objectAt(HTSuffixes, j);
  498.         ls2 = strlen(suff->suffix);
  499.         if ((ls <= lf) && 0==strncasecomp(
  500.             suff->suffix, filename + lf - ls -ls2, ls2)) {
  501.             if (suff->rep) {
  502. #ifdef VMS
  503.             if (semicolon != NULL)
  504.                 *semicolon = ';';
  505. #endif /* VMS */
  506.                 return suff->rep;
  507.             }
  508.         }
  509.         }
  510.         
  511.     }
  512.     }
  513.     
  514.     /* defaults tree */
  515.     
  516.     suff = strchr(filename, '.') ?     /* Unknown suffix */
  517.          ( unknown_suffix.rep ? &unknown_suffix : &no_suffix)
  518.      : &no_suffix;
  519.      
  520.     /* set default encoding unless found with suffix already */
  521.     if (!*pencoding) *pencoding = suff->encoding ? suff->encoding
  522.                     : HTAtom_for("binary");
  523. #ifdef VMS
  524.     if (semicolon != NULL)
  525.         *semicolon = ';';
  526. #endif /* VMS */
  527.     return suff->rep ? suff->rep : WWW_BINARY;
  528. }
  529.  
  530.  
  531. /*    Determine value from file name
  532. **    ------------------------------
  533. **
  534. */
  535.  
  536. PUBLIC float HTFileValue ARGS1 (CONST char *,filename)
  537.  
  538. {
  539.     HTSuffix * suff;
  540.     int n;
  541.     int i;
  542.     int lf = strlen(filename);
  543.  
  544. #ifndef NO_INIT    
  545.     if (!HTSuffixes) HTFileInit();
  546. #endif /* !NO_INIT */
  547.     n = HTList_count(HTSuffixes);
  548.     for(i=0; i<n; i++) {
  549.         int ls;
  550.     suff = HTList_objectAt(HTSuffixes, i);
  551.     ls = strlen(suff->suffix);
  552.     if ((ls <= lf) && 0==strcmp(suff->suffix, filename + lf - ls)) {
  553.         if (TRACE) fprintf(stderr, "File: Value of %s is %.3f\n",
  554.                    filename, suff->quality);
  555.         return suff->quality;        /* OK -- found */
  556.     }
  557.     }
  558.     return 0.3;        /* Dunno! */
  559. }
  560.  
  561.  
  562. /*    Determine write access to a file
  563. **    --------------------------------
  564. **
  565. ** On exit,
  566. **    return value    YES if file can be accessed and can be written to.
  567. **
  568. ** Bugs:
  569. **    1.    No code for non-unix systems.
  570. **    2.    Isn't there a quicker way?
  571. */
  572.  
  573. #ifdef VMS
  574. #define NO_GROUPS
  575. #endif /* VMS */
  576. #ifdef NO_UNIX_IO
  577. #define NO_GROUPS
  578. #endif /* NO_UNIX_IO */
  579. #ifdef PCNFS
  580. #define NO_GROUPS
  581. #endif /* PCNFS */
  582.  
  583. PUBLIC BOOL HTEditable ARGS1 (CONST char *,filename)
  584. {
  585. #ifdef NO_GROUPS
  586.     return NO;        /* Safe answer till we find the correct algorithm */
  587. #else
  588.     int     groups[NGROUPS];    
  589.     uid_t    myUid;
  590.     int        ngroups;            /* The number of groups  */
  591.     struct stat    fileStatus;
  592.     int        i;
  593.         
  594.     if (stat(filename, &fileStatus))        /* Get details of filename */
  595.         return NO;                /* Can't even access file! */
  596.  
  597.     ngroups = getgroups(NGROUPS, groups);    /* Groups to which I belong  */
  598.     myUid = geteuid();                /* Get my user identifier */
  599.  
  600.     if (TRACE) {
  601.         int i;
  602.     fprintf(stderr, 
  603.         "File mode is 0%o, uid=%d, gid=%d. My uid=%d, %d groups (",
  604.             (unsigned int) fileStatus.st_mode, fileStatus.st_uid,
  605.         fileStatus.st_gid,
  606.         myUid, ngroups);
  607.     for (i=0; i<ngroups; i++) fprintf(stderr, " %d", groups[i]);
  608.     fprintf(stderr, ")\n");
  609.     }
  610.     
  611.     if (fileStatus.st_mode & 0002)        /* I can write anyway? */
  612.         return YES;
  613.     
  614.     if ((fileStatus.st_mode & 0200)        /* I can write my own file? */
  615.      && (fileStatus.st_uid == myUid))
  616.         return YES;
  617.  
  618.     if (fileStatus.st_mode & 0020)        /* Group I am in can write? */
  619.     {
  620.        for (i=0; i<ngroups; i++) {
  621.             if (groups[i] == fileStatus.st_gid)
  622.             return YES;
  623.     }
  624.     }
  625.     if (TRACE) fprintf(stderr, "\tFile is not editable.\n");
  626.     return NO;                    /* If no excuse, can't do */
  627. #endif /* NO_GROUPS */
  628. }
  629.  
  630.  
  631. /*    Make a save stream
  632. **    ------------------
  633. **
  634. **    The stream must be used for writing back the file.
  635. **    @@@ no backup done
  636. */
  637. PUBLIC HTStream * HTFileSaveStream ARGS1(HTParentAnchor *, anchor)
  638. {
  639.  
  640.     CONST char * addr = HTAnchor_address((HTAnchor*)anchor);
  641.     char *  localname = HTLocalName(addr);
  642.     
  643.     FILE* fp = fopen(localname, "w");
  644.     if (!fp) return NULL;
  645.     
  646.     return HTFWriter_new(fp);
  647.     
  648. }
  649.  
  650. /*      Output one directory entry
  651. **
  652. */
  653. PUBLIC void HTDirEntry ARGS3(HTStructured *, target,
  654.          CONST char * , tail,
  655.          CONST char *,  entry)
  656. {
  657.     char * relative;
  658.     char * escaped = HTEscape(entry, URL_XPALPHAS);
  659.  
  660.  
  661.     /* handle extra slash at end of path */
  662.     if(*tail == '\0') {
  663.         HTStartAnchor(target, NULL, escaped);
  664.     } else {
  665.         /* If empty tail, gives absolute ref below */
  666.         relative = (char*) malloc(strlen(tail) + strlen(escaped)+2);
  667.         if (relative == NULL) outofmem(__FILE__, "DirRead");
  668.         sprintf(relative, "%s/%s", tail, escaped);
  669.         HTStartAnchor(target, NULL, relative);
  670.         FREE(relative);
  671.     }
  672.     FREE(escaped);
  673. }
  674.  
  675. /*      Output parent directory entry
  676. **
  677. **    This gives the TITLE and H1 header, and also a link
  678. **    to the parent directory if appropriate.
  679. */
  680. PUBLIC void HTDirTitles ARGS2(HTStructured *, target,
  681.          HTAnchor * , anchor)
  682.  
  683. {
  684.     char * logical = HTAnchor_address(anchor);
  685.     char * path = HTParse(logical, "", PARSE_PATH + PARSE_PUNCTUATION);
  686.     char * current;
  687.  
  688.     current = strrchr(path, '/');    /* last part or "" */
  689.  
  690.     {
  691.       char * printable = NULL;
  692.  
  693. #ifdef DIRED_SUPPORT
  694.       StrAllocCopy(printable, path);
  695. #else 
  696.       StrAllocCopy(printable, (current + 1));
  697. #endif /* DIRED_SUPPORT */
  698.  
  699.       START(HTML_HEAD);
  700.       PUTS("\n");
  701.       HTUnEscape(printable);
  702.       START(HTML_TITLE);
  703.       PUTS(*printable ? printable : "Welcome ");
  704.       PUTS(" directory");
  705.       END(HTML_TITLE);
  706.       PUTS("\n");
  707.       END(HTML_HEAD);
  708.       PUTS("\n");
  709.  
  710. #ifdef DIRED_SUPPORT
  711.       START(HTML_H2);
  712.       PUTS(*printable ? "Current directory is " : "");
  713.       PUTS(*printable ? printable : "Welcome");
  714.       END(HTML_H2);
  715.       PUTS("\n");
  716. #else
  717.       START(HTML_H1);
  718.       PUTS(*printable ? printable : "Welcome");
  719.       END(HTML_H1);
  720.       PUTS("\n");
  721. #endif /* DIRED_SUPPORT */
  722.       FREE(printable);
  723.     }
  724.  
  725. #ifndef NO_PARENT_DIR_REFERENCE
  726.     /*  Make link back to parent directory
  727.      */
  728.  
  729.     if (current && current[1]) {   /* was a slash AND something else too */
  730.         char * parent;
  731.     char * relative;
  732.     *current++ = 0;
  733.         parent = strrchr(path, '/');  /* penultimate slash */
  734.  
  735.     relative = (char*) malloc(strlen(current) + 4);
  736.     if (relative == NULL) outofmem(__FILE__, "DirRead");
  737.     sprintf(relative, "%s/..", current);
  738. #ifndef VMS
  739.     {
  740.         /*
  741.          *  On Unix, if it's not ftp and the directory cannot
  742.          *  be read, don't put out a link.
  743.          *
  744.          *  On VMS, this problem is dealt with internally by
  745.          *  HTVMSBrowseDir().
  746.          */
  747.         extern BOOLEAN LYisLocalFile PARAMS((char *logical));
  748.         DIR  * dp=NULL;
  749.  
  750.         if (LYisLocalFile(logical)) {
  751.             if ((dp = opendir(relative)) == NULL) {
  752.                 FREE(logical);
  753.                 FREE(relative);
  754.                 FREE(path);
  755.                 return;
  756.         }
  757.         if (dp)
  758.                 closedir(dp);
  759.         }
  760.     }
  761. #endif /* !VMS */
  762.     HTStartAnchor(target, "", relative);
  763.     FREE(relative);
  764.  
  765. #ifdef DIRED_SUPPORT
  766.     if (dir_list_style != MIXED_STYLE)
  767. #endif /* DIRED_SUPPORT */
  768.         PUTS("Up to ");
  769.     if (parent) {
  770. #ifdef DIRED_SUPPORT
  771.        if (dir_list_style == MIXED_STYLE) {
  772.           PUTS("../");
  773.        } else {
  774. #else
  775.        {
  776. #endif /* DIRED_SUPPORT */
  777.           char * printable = NULL;
  778.           StrAllocCopy(printable, parent + 1);
  779.           HTUnEscape(printable);
  780.           PUTS(printable);
  781.           FREE(printable);
  782.        }
  783.     } else {
  784.       PUTS("/");
  785.     }
  786.  
  787.     END(HTML_A);
  788.     }
  789. #endif /* NO_PARENT_DIR_REFERENCE */
  790.  
  791.     FREE(logical);
  792.     FREE(path);
  793. }
  794.         
  795.  
  796.  
  797. /*    Load a document
  798. **    ---------------
  799. **
  800. ** On entry,
  801. **    addr        must point to the fully qualified hypertext reference.
  802. **            This is the physsical address of the file
  803. **
  804. ** On exit,
  805. **    returns        <0        Error has occured.
  806. **            HTLOADED    OK 
  807. **
  808. */
  809. PUBLIC int HTLoadFile ARGS4 (
  810.     CONST char *,        addr,
  811.     HTParentAnchor *,    anchor,
  812.     HTFormat,        format_out,
  813.     HTStream *,        sink
  814. )
  815. {
  816.     char * filename;
  817.     char * access;
  818.     HTFormat format;
  819.     char * nodename=NULL;
  820.     char * newname=NULL; /* Simplified name of file */
  821.     HTAtom * encoding;     /* @@ not used yet */
  822. #ifdef VMS
  823.     struct stat stat_info;
  824. #endif /* VMS */
  825.  
  826.     FREE(nodename);    /* From prev call - Leak fixed AL 6 Feb 1994 */
  827.     
  828. /*    Reduce the filename to a basic form (hopefully unique!)
  829. */
  830.     StrAllocCopy(newname, addr);
  831.     filename=HTParse(newname, "", PARSE_PATH|PARSE_PUNCTUATION);
  832.     nodename=HTParse(newname, "", PARSE_HOST);
  833.     
  834.     /* If access is ftp, or file is on another host, invoke ftp now */
  835.     access = HTParse(newname, "", PARSE_ACCESS);
  836.     if(strcmp("ftp", access) == 0 ||
  837.        (strcmp("localhost", nodename) != 0 &&
  838. #ifdef VMS
  839.         strcasecomp(nodename, HTHostName()) != 0))
  840. #else
  841.         strcmp(nodename, HTHostName()) != 0))
  842. #endif /* VMS */
  843.     {
  844.         FREE(newname);
  845.         FREE(access);
  846.     FREE(filename);
  847.         return HTFTPLoad(addr, anchor, format_out, sink);
  848.     } else {
  849.         FREE(newname);
  850.         FREE(access);
  851.     }
  852.  
  853. #ifdef VMS
  854. /*
  855. **    Check to see if the 'filename' is in fact a directory.  If it is
  856. **    create a new hypertext object containing a list of files and 
  857. **    subdirectories contained in the directory.  All of these are links
  858. **      to the directories or files listed.
  859. */
  860.     HTUnEscape(filename);
  861.     if (HTStat(filename, &stat_info) == -1) {
  862.     if (TRACE)
  863.         fprintf(stderr, "HTLoadFile.. Can't stat %s\n", filename);
  864.     } else {
  865.     if (((stat_info.st_mode) & S_IFMT) == S_IFDIR) {
  866.         if (HTDirAccess == HT_DIR_FORBID) {
  867.         FREE(filename);
  868.         return HTLoadError(sink, 403,
  869.         "Directory browsing is not allowed.");
  870.         }
  871.  
  872.         if (HTDirAccess == HT_DIR_SELECTIVE) {
  873.         char * enable_file_name = 
  874.             malloc(strlen(filename)+ 1 +
  875.             strlen(HT_DIR_ENABLE_FILE) + 1);
  876.         strcpy(enable_file_name, filename);
  877.         strcat(enable_file_name, "/");
  878.         strcat(enable_file_name, HT_DIR_ENABLE_FILE);
  879.         if (HTStat(enable_file_name, &stat_info) == -1) {
  880.             FREE(filename);
  881.             return HTLoadError(sink, 403,
  882.             "Selective access is not enabled for this directory");
  883.         }
  884.         }
  885.  
  886.         FREE(filename);
  887.         return HTVMSBrowseDir(addr, anchor, format_out, sink);
  888.     }
  889.     }
  890.  
  891.     format = HTFileFormat(filename, &encoding);
  892.  
  893. /* Assume that the file is in Unix-style syntax if it contains a '/'
  894.    after the leading one @@ */
  895.     {
  896.         FILE * fp;
  897.     char * vmsname = strchr(filename + 1, '/') ?
  898.       HTVMS_name(nodename, filename) : filename + 1;
  899.     fp = fopen(vmsname, "r", "shr=put", "shr=upd");
  900.     
  901. /*    If the file wasn't VMS syntax, then perhaps it is ultrix
  902. */
  903.     if (!fp) {
  904.         char ultrixname[INFINITY];
  905.         if (TRACE) fprintf(stderr, "HTFile: Can't open as %s\n", vmsname);
  906.         sprintf(ultrixname, "%s::\"%s\"", nodename, filename);
  907.           fp = fopen(ultrixname, "r", "shr=put", "shr=upd");
  908.         if (!fp) {
  909.         if (TRACE) fprintf(stderr, 
  910.                    "HTFile: Can't open as %s\n", ultrixname);
  911.         }
  912.     }
  913.         if (fp)
  914.         {
  915.         if (HTEditable(vmsname)) {
  916.         HTAtom * put = HTAtom_for("PUT");
  917.         HTList * methods = HTAnchor_methods(anchor);
  918.         if (HTList_indexOf(methods, put) == (-1)) {
  919.                HTList_addObject(methods, put);
  920.             }
  921.         }
  922.         HTParseFile(format, format_out, anchor, fp, sink);
  923.         fclose(fp);
  924.         FREE(filename);
  925.             return HT_LOADED;
  926.         }  /* If successfull open */
  927.     FREE(filename);
  928.     }
  929.  
  930. #else /* Unix: */
  931.  
  932.     format = HTFileFormat(filename, &encoding);
  933.     FREE(filename);
  934.     
  935. /*    For unix, we try to translate the name into the name of a transparently
  936. **    mounted file.
  937. **
  938. **    Not allowed in secure (HTClienntHost) situations TBL 921019
  939. */
  940. #ifndef NO_UNIX_IO
  941.     /*  Need protection here for telnet server but not httpd server */
  942.      
  943.     if (!HTSecure) {        /* try local file system */
  944.     char * localname = HTLocalName(addr);
  945.     struct stat dir_info;
  946. #ifdef LONG_LIST
  947.     char buf[80], type, *datestr;
  948.     struct stat st;
  949.     struct passwd *p;
  950.     struct group *g;
  951.     time_t now;
  952.     static char *pbits[] = { "---", "--x", "-w-", "-wx", 
  953.         "r--", "r-x", "rw-", "rwx", 0 };
  954.     static char *psbits[] = { "--S", "--s", "-wS", "-ws", 
  955.         "r-S", "r-s", "rwS", "rws", 0 };
  956. #define SEC_PER_YEAR    (60 * 60 * 24 * 365)
  957. #define PBIT(a, n, s)  (s) ? psbits[((a) >> (n)) & 0x7] : \
  958.     pbits[((a) >> (n)) & 0x7]
  959. #endif /* LONG_LIST */
  960.     
  961. #ifdef GOT_READ_DIR
  962.  
  963. /*              Multiformat handling
  964. **
  965. **    If needed, scan directory to find a good file.
  966. **  Bug:  we don't stat the file to find the length
  967. */
  968.     if ( (strlen(localname) > strlen(MULTI_SUFFIX))
  969.        && (0==strcmp(localname + strlen(localname) - strlen(MULTI_SUFFIX),
  970.                       MULTI_SUFFIX))) {
  971.         DIR *dp;
  972.  
  973.         STRUCT_DIRENT * dirbuf;
  974.         float best = NO_VALUE_FOUND;    /* So far best is bad */
  975.         HTFormat best_rep = NULL;    /* Set when rep found */
  976.         STRUCT_DIRENT best_dirbuf;    /* Best dir entry so far */
  977.  
  978.         char * base = strrchr(localname, '/');
  979.         int baselen;
  980.  
  981.         if (!base || base == localname) goto forget_multi;
  982.         *base++ = 0;        /* Just got directory name */
  983.         baselen = strlen(base)- strlen(MULTI_SUFFIX);
  984.         base[baselen] = 0;    /* Chop off suffix */
  985.  
  986.         dp = opendir(localname);
  987.         if (!dp) {
  988. forget_multi:
  989.         FREE(localname);
  990.         return HTLoadError(sink, 500,
  991.             "Multiformat: directory scan failed.");
  992.         }
  993.         
  994.         while ((dirbuf = readdir(dp))!=0) {
  995.         /* while there are directory entries to be read */
  996.         if (dirbuf->d_ino == 0)
  997.             continue;    /* if the entry is not being used, skip it */
  998.  
  999.         if (
  1000. #if !defined(SVR4) && !defined(ISC) && !defined(SCO)
  1001.                     (int)dirbuf->d_namlen > baselen &&      /* Match? */
  1002. #endif /* !SVR4 && !ISC && !SCO */
  1003.             !strncmp(dirbuf->d_name, base, baselen)) {    
  1004.             HTFormat rep = HTFileFormat(dirbuf->d_name, &encoding);
  1005.             float value = HTStackValue(rep, format_out,
  1006.                             HTFileValue(dirbuf->d_name),
  1007.                         0.0  /* @@@@@@ */);
  1008.             if (value != NO_VALUE_FOUND) {
  1009.                 if (TRACE) fprintf(stderr,
  1010.                 "HTFile: value of presenting %s is %f\n",
  1011.                 HTAtom_name(rep), value);
  1012.             if  (value > best) {
  1013.                 best_rep = rep;
  1014.                 best = value;
  1015.                 best_dirbuf = *dirbuf;
  1016.                }
  1017.             }    /* if best so far */             
  1018.          } /* if match */  
  1019.             
  1020.         } /* end while directory entries left to read */
  1021.         closedir(dp);
  1022.         
  1023.         if (best_rep) {
  1024.         format = best_rep;
  1025.         base[-1] = '/';        /* Restore directory name */
  1026.         base[0] = 0;
  1027.         StrAllocCat(localname, best_dirbuf.d_name);
  1028.         goto open_file;
  1029.         
  1030.         } else {             /* If not found suitable file */
  1031.         FREE(localname);
  1032.         return HTLoadError(sink, 403,    /* List formats? */
  1033.            "Could not find suitable representation for transmission.");
  1034.         }
  1035.         /*NOTREACHED*/
  1036.     } /* if multi suffix */
  1037. /*
  1038. **    Check to see if the 'localname' is in fact a directory.  If it is
  1039. **    create a new hypertext object containing a list of files and 
  1040. **    subdirectories contained in the directory.  All of these are links
  1041. **      to the directories or files listed.
  1042. **      NB This assumes the existance of a type 'STRUCT_DIRENT', which will
  1043. **      hold the directory entry, and a type 'DIR' which is used to point to
  1044. **      the current directory being read.
  1045. */
  1046.     
  1047.     
  1048.     if (stat(localname,&dir_info) == -1) {     /* get file information */
  1049.                                    /* if can't read file information */
  1050.         if (TRACE) fprintf(stderr, "HTFile: can't stat %s\n", localname);
  1051.  
  1052.     }  else {        /* Stat was OK */
  1053.         
  1054.  
  1055.         if (((dir_info.st_mode) & S_IFMT) == S_IFDIR) {
  1056.         /* if localname is a directory */    
  1057.  
  1058.         HTStructured* target;        /* HTML object */
  1059.         HTStructuredClass targetClass;
  1060.  
  1061.         DIR *dp;
  1062.         STRUCT_DIRENT * dirbuf;
  1063.         
  1064.         char * logical=0;
  1065.         char * pathname=0;
  1066.         char * tail=0;
  1067.         
  1068.         BOOL present[HTML_A_ATTRIBUTES];
  1069.         
  1070.         char * tmpfilename = NULL;
  1071.         struct stat file_info;
  1072.         
  1073.         if (TRACE)
  1074.             fprintf(stderr,"%s is a directory\n",localname);
  1075.             
  1076. /*    Check directory access.
  1077. **    Selective access means only those directories containing a
  1078. **    marker file can be browsed
  1079. */
  1080.         if (HTDirAccess == HT_DIR_FORBID) {
  1081.             FREE(localname);
  1082.             return HTLoadError(sink, 403,
  1083.             "Directory browsing is not allowed.");
  1084.         }
  1085.  
  1086.  
  1087.         if (HTDirAccess == HT_DIR_SELECTIVE) {
  1088.             char * enable_file_name = 
  1089.             malloc(strlen(localname)+ 1 +
  1090.              strlen(HT_DIR_ENABLE_FILE) + 1);
  1091.             strcpy(enable_file_name, localname);
  1092.             strcat(enable_file_name, "/");
  1093.             strcat(enable_file_name, HT_DIR_ENABLE_FILE);
  1094.             if (stat(enable_file_name, &file_info) != 0) {
  1095.             FREE(localname);
  1096.             return HTLoadError(sink, 403,
  1097.             "Selective access is not enabled for this directory");
  1098.             }
  1099.         }
  1100.  
  1101.  
  1102.         dp = opendir(localname);
  1103.         if (!dp) {
  1104.             FREE(localname);
  1105.             return HTLoadError(sink, 403, "This directory is not readable.");
  1106.         }
  1107.  
  1108.  
  1109.  /*    Directory access is allowed and possible
  1110.  */
  1111.         logical = HTAnchor_address((HTAnchor*)anchor);
  1112.             pathname = HTParse(logical, "", 
  1113.                     PARSE_PATH + PARSE_PUNCTUATION);
  1114.  
  1115.             if(!strcmp(pathname,"/"))  /* root path */
  1116.                 StrAllocCopy (tail, "/foo/..");
  1117.                 else
  1118.               {
  1119.                 char * p = strrchr(pathname, '/');  /* find lastslash */
  1120.                 StrAllocCopy(tail, p+1); /* take slash off the beginning */
  1121.               }
  1122.             FREE(pathname);
  1123.         
  1124.         target = HTML_new(anchor, format_out, sink);
  1125.         targetClass = *target->isa;    /* Copy routine entry points */
  1126.             
  1127.           { int i;
  1128.             for(i=0; i<HTML_A_ATTRIBUTES; i++)
  1129.                 present[i] = (i==HTML_A_HREF);
  1130.         }
  1131.         
  1132.                 HTDirTitles(target, (HTAnchor *)anchor);
  1133.  
  1134. #ifdef DIRED_SUPPORT
  1135.         HTAnchor_setFormat((HTParentAnchor *) anchor, WWW_DIRED);
  1136.         lynx_edit_mode = TRUE;
  1137. #endif /* DIRED_SUPPORT */
  1138.                 if (HTDirReadme == HT_DIR_README_TOP)
  1139.             do_readme(target, localname);
  1140.         {
  1141.             HTBTree * bt = HTBTree_new((HTComparer)strcasecomp);
  1142.  
  1143.             while ((dirbuf = readdir(dp))!=0)
  1144.             {
  1145.             /* while there are directory entries to be read */
  1146.                 HTBTElement * dirname = NULL;
  1147.  
  1148.                 if (dirbuf->d_ino == 0)
  1149.                 /* if the entry is not being used, skip it */
  1150.                 continue;
  1151.  
  1152.             if ((*(dirbuf->d_name)=='.') ||
  1153.                 (*(dirbuf->d_name)==','))
  1154.                 /* skip those files whose name begins
  1155.                  * with '.' or ',' */
  1156.                 continue;
  1157.  
  1158.             dirname = (HTBTElement *)malloc(
  1159.                     strlen(dirbuf->d_name) + 4);
  1160.             if (dirname == NULL) outofmem(__FILE__,"DirRead");
  1161.             StrAllocCopy(tmpfilename,localname);
  1162.             if (strcmp(localname,"/")) 
  1163.                 /* if filename is not root directory */
  1164.                 StrAllocCat(tmpfilename,"/"); 
  1165.  
  1166.             StrAllocCat(tmpfilename,dirbuf->d_name);
  1167.             stat(tmpfilename, &file_info);
  1168.             if (((file_info.st_mode) & S_IFMT) == S_IFDIR)
  1169. #ifndef DIRED_SUPPORT
  1170.                     sprintf((char *)dirname,"D%s",dirbuf->d_name);
  1171.             else
  1172.                 sprintf((char *)dirname,"F%s",dirbuf->d_name);
  1173.                 /* D & F to have first directories, then files */
  1174. #else
  1175.                 if (dir_list_style == MIXED_STYLE)
  1176.                     sprintf((char *)dirname," %s/",dirbuf->d_name);
  1177.                 else
  1178.                     sprintf((char *)dirname,"D%s",dirbuf->d_name);
  1179.             else if (dir_list_style == MIXED_STYLE)
  1180.                 sprintf((char *)dirname," %s",dirbuf->d_name);
  1181.             else if (dir_list_style == FILES_FIRST)
  1182.                 sprintf((char *)dirname,"C%s",dirbuf->d_name);
  1183.                 /* C & D to have first files, then directories */
  1184.             else
  1185.                 sprintf((char *)dirname,"F%s",dirbuf->d_name);
  1186. #endif /* !DIRED_SUPPORT */
  1187.             HTBTree_add(bt,dirname); /* Sort dirname in the tree bt */
  1188.             }
  1189.  
  1190.             /*    Run through tree printing out in order
  1191.              */
  1192.             {
  1193.                 HTBTElement * next_element = HTBTree_next(bt,NULL);
  1194.                 /* pick up the first element of the list */
  1195.             char state;
  1196.                 /* I for initial (.. file),
  1197.                    D for directory file,
  1198.                    F for file */
  1199.             
  1200. #ifdef DIRED_SUPPORT
  1201.             char test;
  1202. #endif /* DIRED_SUPPORT */
  1203.             state = 'I';
  1204.  
  1205.             while (next_element != NULL)
  1206.                 {
  1207.                 char *entry, *file_extra;
  1208.  
  1209.                 StrAllocCopy(tmpfilename,localname);
  1210.                 if (strcmp(localname,"/")) 
  1211.  
  1212.                     /* if filename is not root directory */
  1213.                     StrAllocCat(tmpfilename,"/"); 
  1214.  
  1215.                 StrAllocCat(tmpfilename,
  1216.                     (char *)HTBTree_object(next_element)+1);
  1217.                 /* append the current entry's filename to the path */
  1218.                 HTSimplify(tmpfilename);
  1219.                 /* Output the directory entry */
  1220.                 if (strcmp((char *)
  1221.                          (HTBTree_object(next_element)),"D.."))
  1222.                 {                
  1223. #ifdef DIRED_SUPPORT
  1224.                     test = *(char *) (HTBTree_object(next_element))=='D'?'D':'F';
  1225.                 if (state != test)
  1226.                 {
  1227.                     if (dir_list_style == FILES_FIRST) {
  1228.                        if (state == 'F')
  1229.                         END(HTML_DIR); 
  1230.                     } else if (dir_list_style != MIXED_STYLE)
  1231.                        if (state == 'D')
  1232.                         END(HTML_DIR); 
  1233.                     state = *(char *)
  1234.                         (HTBTree_object(next_element))=='D'?'D':'F';
  1235.                     START(HTML_H2);
  1236.                     if (dir_list_style != MIXED_STYLE)
  1237.                        PUTS(state == 'D'?"Directories:":"Files");
  1238. #else
  1239.                 if (state != *(char *)(HTBTree_object(next_element))) 
  1240.                 {
  1241.                     if (state == 'D')
  1242.                         END(HTML_DIR);
  1243.                     state = *(char *)
  1244.                         (HTBTree_object(next_element))=='D'?'D':'F';
  1245.                     START(HTML_H2);
  1246.                     PUTS(state == 'D'?"Subdirectories:":"Files");
  1247. #endif /* DIRED_SUPPORT */
  1248.                     END(HTML_H2);
  1249.                     START(HTML_DIR);
  1250.                 }
  1251.                     START(HTML_LI);
  1252.                 }
  1253.                 entry = (char*)HTBTree_object(next_element)+1;
  1254.                 file_extra = NULL;
  1255. #ifdef LONG_LIST
  1256.                 START(HTML_PRE);
  1257.                 if(lstat(tmpfilename, &st) != -1) {
  1258.                   char link_name[1025];
  1259.                   int file_len;
  1260.  
  1261.                   /* mode (permissions) and link count */
  1262.                   switch(st.st_mode & S_IFMT) {
  1263.                   case S_IFIFO: type = 'p'; break;
  1264.                   case S_IFCHR: type = 'c'; break;
  1265.                   case S_IFDIR: type = 'd'; break;
  1266.                   case S_IFBLK: type = 'b'; break;
  1267.                   case S_IFREG: type = '-'; break;
  1268.                   case S_IFLNK: 
  1269.                 type = 'l'; 
  1270.                 if ((file_len = readlink(tmpfilename,
  1271.                              link_name,
  1272.                              sizeof(link_name) - 1)
  1273.                      ) >=0) {
  1274.                     StrAllocCopy(file_extra, " -> ");
  1275.                     link_name[file_len] = '\0';
  1276.                     StrAllocCat(file_extra, link_name);
  1277.                 }
  1278.                 break;
  1279.                   case S_IFSOCK: type = 's'; break;
  1280.                   default: type = '?'; break;
  1281.                   }
  1282.                   sprintf(buf, "    %c%s%s%s  %3d ", type,
  1283.                     PBIT(st.st_mode, 6, st.st_mode & S_ISUID),
  1284.                     PBIT(st.st_mode, 3, st.st_mode & S_ISGID), 
  1285.                     PBIT(st.st_mode, 0, 0),
  1286.                 st.st_nlink);
  1287.                   PUTS(buf);
  1288.  
  1289.                   /* user */
  1290.                   p = getpwuid(st.st_uid);
  1291.                   if(p) 
  1292.                 sprintf(buf, "%-8.8s ", p->pw_name);
  1293.                   else
  1294.                 sprintf(buf, "%-8d ", st.st_uid);
  1295.                   PUTS(buf);
  1296.  
  1297.                   /* group */
  1298.                   g = getgrgid(st.st_gid);
  1299.                   if(g)
  1300.                 sprintf(buf, "%-8.8s ", g->gr_name);
  1301.                   else
  1302.                 sprintf(buf, "%-8d ", st.st_gid);
  1303.                   PUTS(buf);
  1304.  
  1305.                   /* size */
  1306.                   sprintf(buf, "%7d ", st.st_size);
  1307.                   PUTS(buf);
  1308.  
  1309.                   /* date */
  1310.                   now = time(0);
  1311.                   datestr = ctime(&st.st_mtime);
  1312.                   if((now - st.st_mtime) < SEC_PER_YEAR/2) 
  1313.                 /* MMM DD HH:MM */
  1314.                 sprintf(buf, "%.12s ", datestr + 4);
  1315.                   else 
  1316.                 /* MMM DD  YYYY */
  1317.                 sprintf(buf, "%.7s %.4s ", datestr + 4, 
  1318.                   datestr + 20);
  1319.                   PUTS(buf);
  1320.                 }
  1321. #endif /* LONG_LIST */
  1322.                 HTDirEntry(target, tail, entry);
  1323.                 PUTS(entry);
  1324.                     END(HTML_A);
  1325.                 if (file_extra) {
  1326.                 PUTS(file_extra);
  1327.                 FREE(file_extra);
  1328.                 }
  1329. #ifdef LONG_LIST
  1330.                   END(HTML_PRE);
  1331. #endif /* LONG_LIST */
  1332.  
  1333.                 next_element = HTBTree_next(bt,next_element);
  1334.                     /* pick up the next element of the list; 
  1335.                  if none, return NULL*/
  1336.             }
  1337.             if (state == 'I')
  1338.             {
  1339.                 START(HTML_P);
  1340.                 PUTS("Empty Directory");
  1341.             }
  1342.             else
  1343.                 END(HTML_DIR);
  1344.             }
  1345.  
  1346.                 /* end while directory entries left to read */
  1347.             closedir(dp);
  1348.             FREE(logical);
  1349.             FREE(tmpfilename);
  1350.             FREE(tail);
  1351.             HTBTreeAndObject_free(bt);
  1352.  
  1353.             if (HTDirReadme == HT_DIR_README_BOTTOM)
  1354.               do_readme(target, localname);
  1355.             FREE_TARGET;
  1356.             FREE(localname);
  1357.             return HT_LOADED;    /* document loaded */
  1358.         }
  1359.  
  1360.         } /* end if localname is directory */
  1361.     
  1362.     } /* end if file stat worked */
  1363.     
  1364. /* End of directory reading section
  1365. */
  1366. #endif /* GOT_READ_DIR */
  1367. open_file:
  1368.     {
  1369.         FILE * fp = fopen(localname,"r");
  1370.  
  1371.         if(TRACE) fprintf (stderr, "HTFile: Opening `%s' gives %p\n",
  1372.                 localname, (void*)fp);
  1373.         if (fp) {        /* Good! */
  1374.         if (HTEditable(localname)) {
  1375.             HTAtom * put = HTAtom_for("PUT");
  1376.             HTList * methods = HTAnchor_methods(anchor);
  1377.             if (HTList_indexOf(methods, put) == (-1)) {
  1378.             HTList_addObject(methods, put);
  1379.             }
  1380.         }
  1381.         FREE(localname);
  1382.         HTParseFile(format, format_out, anchor, fp, sink);
  1383.         fclose(fp);
  1384.         return HT_LOADED;
  1385.         }  /* If succesfull open */
  1386.     }    /* scope of fp */
  1387.     }  /* local unix file system */    
  1388. #endif /* !NO_UNIX_IO */
  1389. #endif /* VMS */
  1390.  
  1391. #ifndef DECNET
  1392. /*    Now, as transparently mounted access has failed, we try FTP.
  1393. */
  1394.     {
  1395.     /** Deal with case-sensitivity differences on VMS verus Unix **/
  1396. #ifdef VMS
  1397.         if (strcasecomp(nodename, HTHostName())!=0)
  1398. #else
  1399.     if (strcmp(nodename, HTHostName())!=0)
  1400. #endif /* VMS */
  1401.         if(!strncmp(addr,"file://localhost",16))
  1402.             return -1;  /* never go to ftp site when URL
  1403.                  * is file://localhost
  1404.                  */
  1405.         else
  1406.             return HTFTPLoad(addr, anchor, format_out, sink);
  1407.     }
  1408. #endif /* !DECNET */
  1409.  
  1410. /*    All attempts have failed.
  1411. */
  1412.     {
  1413.         if (TRACE)
  1414.         fprintf(stderr, "Can't open `%s', errno=%d\n", addr, SOCKET_ERRNO);
  1415.  
  1416.     return HTLoadError(sink, 403, "Can't access requested file.");
  1417.     }
  1418.     
  1419.  
  1420. }
  1421.  
  1422. /*        Protocol descriptors
  1423. */
  1424. GLOBALDEF PUBLIC HTProtocol HTFTP  = { "ftp", HTLoadFile, 0 };
  1425. GLOBALDEF PUBLIC HTProtocol HTFile = { "file", HTLoadFile, HTFileSaveStream };
  1426.